home *** CD-ROM | disk | FTP | other *** search
/ Cream of the Crop 26 / Cream of the Crop 26.iso / program / p063b9s.zip / UNIT / NEWIMP.PAS < prev    next >
Pascal/Delphi Source File  |  1996-04-20  |  38KB  |  982 lines
  1. UNIT NewImp;
  2. {╔══════════════════════════════════════════════════════════════════════════╗}
  3. {║ New Import                                    Last changed: 20.04.96  SA ║}
  4. {║                                                                          ║}
  5. {║                         (C) Copyright 1989-94 by                         ║}
  6. {║       Dan Wulff, Jens Sandalgaard, Steen Christensen & S¢ren Ager        ║}
  7. {║                                                                          ║}
  8. {║ This source can be distributed freely, as long as it is done in a        ║}
  9. {║ lawfull and friendly manner.                                             ║}
  10. {╚══════════════════════════════════════════════════════════════════════════╝}
  11.  
  12. INTERFACE
  13.  
  14. USES Use32;
  15.  
  16. PROCEDURE ImportConfig;
  17.  
  18. IMPLEMENTATION
  19.  
  20. USES Oproot, Opstring, Dos, PopTypes, Resource, StrUtil, Netfile, LogFile,
  21.      MailUtil, Globals, Input, OpDate, OpWindow, Oproutil;
  22.  
  23.   PROCEDURE ImportConfig;
  24.   VAR
  25.     MainStrDict : StringDictPtr;
  26.     TmpFile     : TNetFile;
  27.     Oldsection,
  28.     Section,
  29.     TokenNr     : LongInt;
  30.     Fname       : PathStr;
  31.     AstCount,
  32.     AdrNum      : Byte;
  33.     TickRec     : TTickArea;
  34.     FileFwdRec  : TFileFwd;
  35.     nltrec      : TNLTranslat;
  36.     ScdRec      : TSchedule;
  37.     okfrec      : Tokfile;
  38.     AreaRec     : TMsgArea;
  39.     NlsRec      : TNodelistseg;
  40.     Win         : WindowPtr;
  41.     Overwrite   : Boolean;
  42.     MFSrec      : TFileListSegment;
  43.  
  44.     PROCEDURE Split(s: String; VAR Token, Rest: String);
  45.     BEGIN
  46.       s:=trimspaces(s);
  47.       Token:=StUpCase(NextWord(' ',s));
  48.       Rest:=s;
  49.     END;
  50.  
  51.     PROCEDURE ImportFile(FName: PathStr);
  52.     VAR
  53.       LocalStrDict : StringDictPtr;
  54.       f : Text;
  55.       s : String;
  56.       Token, Rest  : STRING;
  57.  
  58.       FUNCTION TrimRest:STRING;
  59.       BEGIN
  60.         TrimRest:=TrimSpaces(Rest);
  61.       END;
  62.  
  63.       FUNCTION BooleanRest:BOOLEAN;
  64.       BEGIN
  65.         BooleanRest:=(StUpCase(TrimRest)='YES');
  66.       END;
  67.  
  68.       PROCEDURE ImportSystem;
  69.       VAR
  70.         Test2  : Longint;
  71.         Test   : integer;
  72.         z      : byte;
  73.       BEGIN
  74.         CASE TokenNr OF
  75.            1 : Val(rest, Cfg.Version, test);
  76.            2 : Val(rest, Cfg.Tasknumber, test);
  77.            3 : cfg.Swapdir:=Trimrest;
  78.            4 : cfg.OutBound:=trimrest;
  79.            5 : Cfg.Banner:=trimrest;
  80.            6 : Cfg.DefaultMacro:=trimrest;
  81.            7 : cfg.Editor:=trimrest;
  82.            8 : cfg.LogFileName:=trimrest;
  83.            9 : Val(rest, cfg.loglevel, test);
  84.           10 : cfg.UseYearinlog:=BooleanRest;
  85.           11 : cfg.nodelist:=trimrest;
  86.           12 : BEGIN
  87.                  if MainStrDict^.Member(TrimRest, test2) then
  88.                    cfg.Nodelisttyp:=NodelistType(Test2 - 520);
  89.                END;
  90.           13 : Val(rest, cfg.mainAdrNum, test);
  91.           14 : BEGIN
  92.                  Rest:=trimspaces(rest);
  93.                  Inc(Adrnum);
  94.                  GetAdressFromStr(Rest,Cfg.Addresses[AdrNum]);
  95.                END;
  96.           15 : Val(rest, cfg.Pointnet, test);
  97.           16 : Cfg.UsefakeAddress:=BooleanRest;
  98.           17 : cfg.Sysop:=TrimRest;
  99.           18 : Cfg.System:=TrimRest;
  100.           19 : Cfg.SwapOnExec:=BooleanRest;
  101.           20 : Cfg.EnterBBSText:=TrimRest;
  102.           21 : Cfg.DoingMailText:=TrimRest;
  103.           22 : Cfg.PressESCText:=TrimRest;
  104.           23 : Val(TrimRest,cfg.maxringing, test);
  105.           24 : BEGIN
  106.                  rest:=TrimRest;
  107.                  cfg.Zmhstart:=TimestringtoTime('hh:mm',copy(rest,1,5));
  108.                  cfg.zmhend:=timestringtotime('hh:mm',copy(rest,7,5));
  109.                END;
  110.           25 : Cfg.CallTime:=TimeStringToTime('hh:mm:ss',TrimRest);
  111.           26 : Cfg.CallWidth:=TimeStringToTime('hh:mm:ss',TrimRest);
  112.           27 : Cfg.ConnectFastest:=BooleanRest;
  113.           28 : Cfg.OutReReadDelay:=TimeStringToTime('hh:mm:ss',TrimRest);
  114.           29 : cfg.FuncReqPwd:=TrimRest;
  115.           30 : Cfg.UseJanus:=BooleanRest;
  116.           31 : cfg.UseEmsi:=BooleanRest;
  117.           32 : Cfg.FastCalls:=BooleanRest;
  118.           33 : Cfg.KeepEmptyDirs:=BooleanRest;
  119.           34 : Cfg.Curmudgeon:=BooleanRest;
  120.           35 : Cfg.ReReadOnCall:=BooleanRest;
  121.           36 : Cfg.Inbound[NsUnknown]:=TrimRest;
  122.           37 : cfg.Inbound[NsKnown]:=TrimRest;
  123.           38 : Cfg.Inbound[NsPassword]:=TrimRest;
  124.           39 : Val(TrimRest,cfg.inboundToDo[NsUnknown],test);
  125.           40 : Val(TrimRest,cfg.inboundToDo[Nsknown],test);
  126.           41 : Val(TrimRest,cfg.inboundToDo[Nspassword],test);
  127.           42 : BEGIN
  128.                  rest:=TrimRest;
  129.                  if rest[1]='C' then z:=1 else z:=2;
  130.                  Val(copy(rest,2,2),test2, test);
  131.                  delete(rest,1,4);
  132.                  Val(NextWord('@',rest),cfg.fkey[z,test2].Errorlevel,test);
  133.                  cfg.fkey[z,test2].Description:=rest;
  134.                END;
  135.         END;
  136.       END;
  137.  
  138.       PROCEDURE ImportBBs;
  139.       Var
  140.         Test  : longint;
  141.         test2 : integer;
  142.       BEGIN
  143.         CASE TokenNr of
  144.           1 : BEGIN
  145.                 if MainStrDict^.Member(TrimRest, test) then
  146.                   Byte(Cfg.BBs.BBsType):=Test - 500;
  147.  
  148.               END;
  149.           2 : cfg.BBs.Path:=TrimRest;
  150.           3 : cfg.BBs.UserFile:=TrimRest;
  151.           4 : Val(TrimRest,cfg.bbs.minbaud,test2);
  152.           5 : Cfg.BBs.MinBaudFile:=TrimRest;
  153.           6 : Val(TrimRest,cfg.bbs.userErrorLevel,test2);
  154.           7 : BEGIN
  155.                 rest:=TrimRest;
  156.                 Val(NextWord(' ',rest),test,test2);
  157.                 cfg.bbs.Multi[test].key:=rest[1];
  158.                 delete(rest,1,2);
  159.                 cfg.bbs.Multi[test].BatName:=rest;
  160.               END;
  161.         END;
  162.       END;
  163.  
  164.       PROCEDURE ImportModem;
  165.       Var
  166.         test3,
  167.         test2,
  168.         test : Integer;
  169.  
  170.       BEGIN
  171.         CASE TokenNr of
  172.           1  : Val(TrimRest,cfg.Modem.CommPort, test);
  173.           2  : Val(TrimRest,cfg.modem.BaudRate, test);
  174.           3  : Cfg.Modem.PreInit:=TrimRest;
  175.           4  : Cfg.Modem.Init:=TrimRest;
  176.           5  : Cfg.Modem.NoAnswer:=TrimRest;
  177.           6  : Cfg.Modem.Dial:=TrimRest;
  178.           7  : Cfg.Modem.Busy:=TrimRest;
  179.           8  : Cfg.Modem.HangUp:=TrimRest;
  180.           9  : Cfg.Modem.Answer:=TrimRest;
  181.           10 : Cfg.Modem.ReInit:=TimeStringToTime('hh:mm:ss',TrimRest);
  182.           11 : Cfg.Modem.LockedBaud:=TrimRest;
  183.           12 : BEGIN
  184.                  rest:=TrimRest;
  185.                  Val(NextWord(' ',Rest),test2,test);
  186.                  Cfg.Modem.ExitStr[test2].ConStr:=NextWord('@',rest);
  187.                  Val(rest,Cfg.Modem.ExitStr[test2].Errlvl,test);
  188.                END;
  189.           13 : BEGIN
  190.                  rest:=TrimRest;
  191.                  Val(NextWord(' ',rest),test3,test);
  192.                  Val(NextWord('@',rest),Cfg.Modem.ModemType[Test3].Bit,test);
  193.                  cfg.Modem.ModemType[test3].Dial:=NextWord('@',Rest);
  194.                  Cfg.Modem.ModemType[test3].DialOut:=NextWord('@',rest)='YES';
  195.                  Val(rest,cfg.modem.ModemType[test3].Baud,test);
  196.                END;
  197.           14 : Cfg.Modem.WaitTime:=TimeStringToTime('hh:mm:ss',TrimRest);
  198.           15 : Cfg.Modem.InternalFax:=BooleanRest;
  199.           16 : Cfg.Modem.LinkStat:=TrimRest;
  200.           17 : Val(TrimRest, Cfg.Modem.LogLines, Test);
  201.           18 : BEGIN
  202.                  Rest:=TrimRest;
  203.                  Val(NextWord(' ',Rest), test2, test);
  204.                  Cfg.Statistics.MdmProtocol[test2]:=Rest;
  205.                END;
  206.         END;
  207.       END;
  208.  
  209.       PROCEDURE ImportScreen;
  210.       BEGIN
  211.         CASE TokenNr of
  212.           1 : Cfg.Screen.BlankTime:=TimeStringToTime('hh:mm:ss',TrimRest);
  213.           2 : Cfg.Screen.chkSnow:=BooleanRest;
  214.           3 : Cfg.Screen.KeepOffScrMode:=BooleanRest;
  215.           4 : Cfg.Screen.ScrMode:=BooleanRest;
  216.           5 : Cfg.Screen.HardWareBlank:=BooleanRest;
  217.           6 : Cfg.Screen.ExplodingWin:=BooleanRest;
  218.         END;
  219.       END;
  220.  
  221.       PROCEDURE ImportListFile;
  222.       Var
  223.         test2,
  224.         test : integer;
  225.       BEGIN
  226.         CASE TokenNr of
  227.            1 : cfg.ListFiles.FileList:=TrimRest;
  228.            2 : Cfg.ListFiles.NewsList:=TrimRest;
  229.            3 : Cfg.ListFiles.Header:=TrimRest;
  230.            4 : Cfg.ListFiles.Footer:=TrimRest;
  231.            5 : Cfg.ListFiles.TopFile:=TrimRest;
  232.            6 : Cfg.ListFiles.StatFile:=TrimRest;
  233.            7 : Cfg.ListFiles.Adopt:=BooleanRest;
  234.            8 : Cfg.ListFiles.AdoptComment:=TrimRest;
  235.            9 : Cfg.ListFiles.DupeCheck:=BooleanRest;
  236.           10 : Cfg.ListFiles.Stat:=BooleanRest;
  237.           11 : Cfg.ListFiles.IncludeTop:=BooleanRest;
  238.           12 : Val(TrimRest,Cfg.ListFiles.Top,test);
  239.           13 : Cfg.ListFiles.DkDate:=BooleanRest;
  240.           14 : Val(TrimRest,Cfg.ListFiles.NewsDays,test);
  241.           15 : Val(TrimRest,Cfg.Listfiles.thresHold,test);
  242.           16 : Cfg.ListFiles.RemMissing:=BooleanRest;
  243.           17 : Cfg.ListFiles.OkPortal:=BooleanRest;
  244.           18 : Cfg.ListFiles.ZapZero:=BooleanRest;
  245.           19 : Cfg.ListFiles.Touch:=BooleanRest;
  246.           20 : BEGIN
  247.                  rest:=TrimRest;
  248.                  Val(NextWord(' ',rest),Test2,test);
  249.                  Cfg.ListFiles.CrapFiles[test2]:=rest;
  250.                END;
  251.           21 : BEGIN
  252.                  rest:=TrimRest;
  253.                  Val(NextWord(' ',rest),Test2,test);
  254.                  Cfg.ListFiles.ExcludeFiles[test2]:=rest;
  255.                END;
  256.           22 : BEGIN
  257.                  rest:=TrimRest;
  258.                  Val(NextWord(' ',rest),Test2,test);
  259.                  Cfg.ListFiles.NoDupeCheck[test2]:=rest;
  260.                END;
  261.           23 : BEGIN
  262.                  rest:=TrimRest;
  263.                  Val(NextWord(' ',rest),Test2,test);
  264.                  Cfg.ListFiles.NonAdoptFiles[test2]:=rest;
  265.                END;
  266.           24 : BEGIN
  267.                  rest:=TrimRest;
  268.                  Val(NextWord(' ',rest),Test2,test);
  269.                  Cfg.ListFiles.NonAdoptAreas[test2]:=rest;
  270.                END;
  271.           25 : BEGIN
  272.                  rest:=TrimRest;
  273.                  Val(NextWord(' ',rest),Test2,test);
  274.                  Cfg.ListFiles.PrivateAreas[test2]:=rest;
  275.                END;
  276.           26 : Cfg.ListFiles.DoBefore:=TrimRest;
  277.           27 : Cfg.ListFiles.DoAfter:=TrimRest;
  278.           28 : Cfg.ListFiles.DoPack:=TrimRest;
  279.           29 : Cfg.ListFiles.DupeReport:=TrimRest;
  280.           30 : BEGIN
  281.                  Rest:=TrimRest;
  282.                  Val(NextWord(' ',rest),test2,test);
  283.                  Cfg.ListFiles.TXTFreq[test2]:=Rest;
  284.                END;
  285.           31 : Cfg.ListFiles.OkBimodemPath:=TrimRest;
  286.         END;
  287.       END;
  288.  
  289.       PROCEDURE ImportRequest;
  290.       Var
  291.         test : integer;
  292.       BEGIN
  293.         CASE TokenNr of
  294.            1 : Val(TrimRest,Cfg.Request.Limit[NsUnknown,RlPrDay].MaxFiles,test);
  295.            2 : Val(TrimRest,Cfg.Request.Limit[NsUnknown,RlPrcall].MaxFiles,test);
  296.            3 : Cfg.request.Limit[NsUnKnown,RlPrDay].Maxtime:=TimeStringToTime('hh:mm:ss',TrimRest);
  297.            4 : Cfg.request.Limit[NsUnKnown,RlPrcall].MaxTime:=TimeStringToTime('hh:mm:ss',TrimRest);
  298.            5 : Val(TrimRest,Cfg.Request.Limit[NsUnknown,RlPrDay].MaxBytes,test);
  299.            6 : Val(TrimRest,Cfg.Request.Limit[NsUnknown,RlPrcall].MaxBytes,test);
  300.            7 : Val(TrimRest,Cfg.Request.Limit[Nsknown,RlPrDay].MaxFiles,test);
  301.            8 : Val(TrimRest,Cfg.Request.Limit[Nsknown,RlPrcall].MaxFiles,test);
  302.            9 : Cfg.request.Limit[NsKnown,RlPrDay].Maxtime:=TimeStringToTime('hh:mm:ss',TrimRest);
  303.           10 : Cfg.request.Limit[NsKnown,RlPrcall].MaxTime:=TimeStringToTime('hh:mm:ss',TrimRest);
  304.           11 : Val(TrimRest,Cfg.Request.Limit[Nsknown,RlPrDay].MaxBytes,test);
  305.           12 : Val(TrimRest,Cfg.Request.Limit[Nsknown,RlPrcall].MaxBytes,test);
  306.           13 : Val(TrimRest,Cfg.Request.Limit[NsPassWord,RlPrDay].MaxFiles,test);
  307.           14 : Val(TrimRest,Cfg.Request.Limit[NsPassword,RlPrcall].MaxFiles,test);
  308.           15 : Cfg.request.Limit[NsPassword,RlPrDay].Maxtime:=TimeStringToTime('hh:mm:ss',TrimRest);
  309.           16 : Cfg.request.Limit[NsPassword,RlPrcall].MaxTime:=TimeStringToTime('hh:mm:ss',TrimRest);
  310.           17 : Val(TrimRest,Cfg.Request.Limit[Nspassword,RlPrDay].MaxBytes,test);
  311.           18 : Val(TrimRest,Cfg.Request.Limit[NsPassword,RlPrcall].MaxBytes,test);
  312.           19 : Cfg.Request.RspAsPkt:=BooleanRest;
  313.           20 : Cfg.Request.SkipAfterFirst:=BooleanRest;
  314.           21 : Val(TrimRest,Cfg.Request.MinBaud,test);
  315.           22 : Val(TrimRest,Byte(Cfg.Request.ReqOnUs),test);
  316.           23 : Val(TrimRest,Cfg.Request.ReqOnUsCost,test);
  317.         END;
  318.       END;
  319.  
  320.       PROCEDURE ImportMailScanner;
  321.       Var
  322.         test : integer;
  323.       BEGIN
  324.         CASE TokenNr of
  325.            1 : Cfg.MailScanner.NetMailDir:=TrimRest;
  326.            2 : Cfg.MailScanner.Secure:=BooleanRest;
  327.            3 : Cfg.MailScanner.BadMsgs:=TrimRest;
  328.            4 : Cfg.MailScanner.SaveDupesDir:=TrimRest;
  329.            5 : Val(TrimRest,Cfg.MailScanner.MaxDupes,test);
  330.            6 : Cfg.MailScanner.EchotossLog:=TrimRest;
  331.            7 : Cfg.MailScanner.StripCrash:=BooleanRest;
  332.            8 : Cfg.MailScanner.SetAKASent:=BooleanRest;
  333.            9 : Cfg.MailScanner.PvtEchoMail:=BooleanRest;
  334.           10 : Cfg.MailScanner.SaveFwdMail:=BooleanRest;
  335.           11 : Cfg.MailScanner.routeFile:=TrimRest;
  336.           12 : Cfg.MailScanner.ForWardMail:=BooleanRest;
  337.           13 : Cfg.MailScanner.KillFWdFiles:=BooleanRest;
  338.           14 : Cfg.MailScanner.OldExt:=BooleanRest;
  339.           15 : Val(TrimRest,cfg.MailScanner.DefaultPacker,test);
  340.           16 : Val(TrimRest,cfg.MailScanner.NetMailBoard,test);
  341.         END;
  342.       END;
  343.  
  344.       PROCEDURE ImportFileFwd;
  345.       Var
  346.         test : Integer;
  347.       BEGIN
  348.         CASE TokenNr of
  349.           1 : Cfg.FwdFile.preCmd:=TrimRest;
  350.           2 : Cfg.FwdFile.SecureDir:=TrimRest;
  351.           3 : Val(TrimRest,cfg.FwdFile.MsgAttribute,test);
  352.           4 : Cfg.FwdFile.KillSent:=BooleanRest;
  353.           5 : Cfg.FwdFile.MsgPrivate:=BooleanRest;
  354.           6 : Cfg.FwdFile.Subject:=TrimRest;
  355.         END;
  356.       END;
  357.  
  358.       PROCEDURE ImportTick;
  359.       BEGIN
  360.         CASE TokenNr of
  361.           1 : Cfg.Tick.DupeDir:=TrimRest;
  362.           2 : Cfg.Tick.HoldDir:=TrimRest;
  363.           3 : Cfg.Tick.BeforeMoving:=TrimRest;
  364.           4 : Cfg.Tick.RequestMissing:=BooleanRest;
  365.         END;
  366.       END;
  367.  
  368.       PROCEDURE ImportBiMail;
  369.       Var
  370.         test2,
  371.         test : Integer;
  372.  
  373.       BEGIN
  374.         CASE tokenNr Of
  375.           1 : BEGIN
  376.                 rest:=TrimRest;
  377.                 Val(NextWord(' ',rest),test2,test);
  378.                 Cfg.Bimail.BiOverRide[Test2]:=Rest;
  379.               END;
  380.           2 : Cfg.Bimail.NoSendOverRide:=BooleanRest;
  381.           3 : Val(TrimRest, Cfg.Bimail.MaxBaud,test);
  382.           4 : Cfg.BiMail.BiModemPath:=TrimRest;
  383.         END;
  384.       END;
  385.  
  386.       PROCEDURE ImportNodeListComp;
  387.       Var
  388.         Test,
  389.         Test2 : Integer;
  390.  
  391.       BEGIN
  392.         CASE TokenNr of
  393.           1 : Cfg.NlCompiler.CostFileName:=TrimRest;
  394.           2 : Cfg.NlCompiler.IntPreFix:=TrimRest;
  395.           3 : Cfg.Nlcompiler.OurPreFix:=TrimRest;
  396.           4 : Cfg.NlCompiler.UseFidoUserLst:=BooleanRest;
  397.           5 : BEGIN
  398.                 rest:=TrimRest;
  399.                 Val(NextWord(' ',rest), test2, test);
  400.                 if test=0 then Cfg.NlCompiler.MtypeStr[Test2]:=rest;
  401.               END;
  402.         END;
  403.       END;
  404.  
  405.       PROCEDURE ImportDumbTerm;
  406.       BEGIN
  407.         CASE TokenNr of
  408.           1 : Cfg.DumbTerm.CrSendsLF:=BooleanRest;
  409.           2 : Cfg.DumbTerm.DestructiveBS:=BooleanRest;
  410.           3 : Cfg.DumbTerm.ModemInit:=TrimRest;
  411.         END;
  412.       END;
  413.  
  414.       PROCEDURE ImportExtprot;
  415.       var
  416.         test,
  417.         test2 : integer;
  418.       BEGIN
  419.         rest:=TrimRest;
  420.         Val(NextWord(' ',rest),test2,test);
  421.         CASE TokenNr of
  422.           1 : Cfg.ExtProt[test2].Key:=rest[1];
  423.           2 : Cfg.ExtProt[test2].Name:=Rest;
  424.           3 : Cfg.ExtProt[test2].AskdlName:=rest='YES';
  425.           4 : Cfg.ExtProt[test2].AutoStart:=Rest;
  426.           5 : Cfg.ExtProt[test2].SendCmd:=Rest;
  427.           6 : Cfg.ExtProt[test2].RecvCmd:=Rest;
  428.         END;
  429.       END;
  430.  
  431.       PROCEDURE ImportAreaMan;
  432.       var
  433.         test : Integer;
  434.       BEGIN
  435.         Rest:=TrimRest;
  436.         CASE TokenNr of
  437.            1 : Cfg.areaMan.DlCntStart:=rest[1];
  438.            2 : Cfg.areaMan.DlCntStop:=rest[1];
  439.            3 : Cfg.AreaMan.AdoptDefault:=rest='YES';
  440.            4 : Cfg.AreaMan.InsDlCnt:=rest='YES';
  441.            5 : Cfg.AreaMan.AddInbound:=rest='YES';
  442.            6 : Val(rest, Cfg.AreaMan.FirstArea, test);
  443.            7 : Val(rest, Cfg.AreaMan.LastArea, test);
  444.            8 : Val(rest, Cfg.AreaMan.DlCDigits, test);
  445.            9 : Cfg.AreaMan.DlCZeroFill:=rest='YES';
  446.           10 : Cfg.AreaMan.ViewCmd:=rest;
  447.         END;
  448.       END;
  449.  
  450.       PROCEDURE ImportPackers;
  451.       Var
  452.         test2,
  453.         Test : Integer;
  454.       BEGIN
  455.         rest:=TrimRest;
  456.         Val(NextWord(' ',rest),test2,test);
  457.         CASE TokenNr of
  458.           1 : Cfg.Packer[test2].AddCmd:=Rest;
  459.           2 : Cfg.Packer[test2].UnPackCmd:=Rest;
  460.           3 : Cfg.Packer[test2].EraseCmd:=Rest;
  461.           4 : Cfg.Packer[test2].TestCmd:=Rest;
  462.         END;
  463.       END;
  464.  
  465.       PROCEDURE ImportEventfile;
  466.       Var
  467.         DelStr    : String;
  468.         w         : LongInt;
  469.         Test      : Integer;
  470.       BEGIN
  471.         CASE TokenNr of
  472.            1 : BEGIN
  473.                  FillChar(CurrentEvent,Sizeof(TEvent),#0);
  474.                  Rest:=Rest+' ';
  475.                  WHILE Rest<>'' DO
  476.                  BEGIN
  477.                    rest:=TrimLead(rest);
  478.                    DelStr:=NextWord(' ',rest);
  479.                    IF MainStrDict^.Member(DelStr,w) THEN
  480.                    BEGIN
  481.                      CASE w OF
  482.                        110 : CurrentEvent.Active:=CurrentEvent.active OR 128;
  483.                   120..126 : CurrentEvent.Active:=CurrentEvent.Active OR (1 SHL (w-120));
  484.                      END;
  485.                    END;
  486.                  END;
  487.                END;
  488.            2 : CurrentEvent.Start:=TimeStringToTime('HH:MM',TrimRest);
  489.            3 : Val(TrimRest,CurrentEvent.Month,Test);
  490.            4 : Val(TrimRest,CurrentEvent.Day,Test);
  491.            5 : Val(TrimRest,CurrentEvent.InitExit,Test);
  492.            6 : Val(TrimRest,CurrentEvent.MailExit,Test);
  493.            7 : Val(TrimRest,CurrentEvent.PollExit,Test);
  494.            8 : Val(TrimRest,CurrentEvent.FilesExit,Test);
  495.            9 : BEGIN
  496.                  Rest:=Rest+' ';
  497.                  WHILE Rest<>'' DO
  498.                  BEGIN
  499.                    Rest:=TrimLead(Rest);
  500.                    DelStr:=NextWord(' ',Rest);
  501.                    IF LocalStrDict^.Member(DelStr,w) THEN
  502.                    BEGIN
  503.                      CurrentEvent.Typ:=CurrentEvent.Typ OR (1 SHL (w-101));
  504.                    END;
  505.                  END;
  506.                END;
  507.           10 : Val(TrimRest,CurrentEvent.Tries.Bad,Test);
  508.           11 : Val(TrimRest,CurrentEvent.Tries.Busy,Test);
  509.           12 : CurrentEvent.CallTime:=TimeStringToTime('HH:MM:SS',TrimRest);
  510.           13 : CurrentEvent.CallWidth:=TimeStringToTime('HH:MM:SS',TrimRest);
  511.           14 : CurrentEvent.Description:=TrimRest;
  512.           15 : GetAdressFromStr(TrimRest,CurrentEvent.ConnectTo);
  513.           16 : Val(TrimRest,CurrentEvent.SchedNumber,Test);
  514.           17 : Val(TrimRest,CurrentEvent.MaxCost,Test);
  515.           18 : Val(TrimRest,CurrentEvent.MinMail,Test);
  516.           19 : Val(TrimRest,CurrentEvent.SpecDial,Test);
  517.           20 : Val(TrimRest,CurrentEvent.TaskNumber,Test);
  518.         END;
  519.       END;
  520.  
  521.       PROCEDURE ImportNodesfile;
  522.       Var
  523.         DelStr    : String;
  524.         w         : LongInt;
  525.         Test      : Integer;
  526.       BEGIN
  527.         rest:=TrimRest;
  528.         CASE TokenNr of
  529.            1 : GetAdressFromStr(Rest,NodesRec.Address);
  530.            2 : NodesRec.PktPassword:=rest;
  531.            3 : NodesRec.AreaFixPwd:=Rest;
  532.            4 : NodesRec.SessionPwd:=Rest;
  533.            5 : Val(Rest,NodesRec.PackerType,Test);
  534.            6 : Val(Rest,NodesRec.Level,Test);
  535.            7 : Val(Rest,NodesRec.keys,Test);
  536.            8 : NodesRec.OpenFrom:=TimeStringToTime('HH:MM:SS',Rest);
  537.            9 : NodesRec.OpenTo:=TimeStringToTime('HH:MM:SS',Rest);
  538.           10 : NodesRec.UseEmsi:=rest[1];
  539.           11 : NodesRec.SendFwdLetter:=rest='YES';
  540.           12 : Val(Rest,NodesRec.PointNet,Test);
  541.           13 : NodesRec.CheckConnect:=rest[1];
  542.           14 : NodesRec.UseFake:=rest[1];
  543.           15 : NodesRec.DisallowReq:=Rest='YES';
  544.           16 : NodesRec.UseFullDuplex:=rest[1];
  545.           17 : NodesRec.Phone:=Rest;
  546.           18 : NodesRec.TickPassword:=Rest;
  547.           19 : NodesRec.PackTick:=rest='YES';
  548.           20 : NodesRec.Flavor:=rest[1];
  549.           21 : BEGIN
  550.                  NodesRec.SpecialDials[1]:=copy(rest,1,Pos('■',rest)-1);
  551.                  NodesRec.SpecialDials[2]:=Copy(rest,Pos('■',rest)+1,255);
  552.                END;
  553.           22 : NodesRec.EmsiSetTime:=Rest='YES';
  554.           23 : Val(Rest,NodesRec.MinConnectBaud,Test);
  555.         END;
  556.       END;
  557.  
  558.       PROCEDURE ImportTickfile;
  559.       Var
  560.         DelStr    : String;
  561.         w         : LongInt;
  562.         Test      : Integer;
  563.  
  564.       BEGIN
  565.         rest:=TrimRest;
  566.         CASE TokenNr of
  567.            1 : TickRec.AreaName:=Rest;
  568.            2 : TickRec.GroupName:=Rest;
  569.            3 : TickRec.HumanName:=Rest;
  570.            4 : TickRec.Areapath:=Rest;
  571.            5 : TickRec.WriteLetter:=Rest='YES';
  572.            6 : TickRec.AnnouncePath:=Rest;
  573.            7 : TickRec.CanBeRepacked:=Rest='YES';
  574.            8 : BEGIN
  575.                  rest:=Rest+' ';
  576.                  TickRec.GetFrom[1]:=copy(rest,1,Pos('@',rest)-1);
  577.                  TickRec.GetFrom[2]:=copy(rest,Pos('@',rest)+1,255);
  578.                END;
  579.            9 : BEGIN
  580.                  rest:=Rest+' ';
  581.                  TickRec.SendTo[1]:=copy(rest,1,Pos('@',rest)-1);
  582.                  TickRec.SendTo[2]:=copy(rest,Pos('@',rest)+1,255);
  583.                END;
  584.           10 : Val(Rest,TickRec.Level,Test);
  585.           11 : Val(Rest,TickRec.keys,Test);
  586.           12 : TickRec.CheckCRC:=Rest='YES';
  587.           13 : TickRec.FilesBBs:=Rest;
  588.           14 : Val(Rest,TickRec.AkaToUse,Test);
  589.           15 : TickRec.CheckDupe:=rest='YES';
  590.         END;
  591.       END;
  592.  
  593.       PROCEDURE ImportfileForward;
  594.       Var
  595.         DelStr    : String;
  596.         w         : LongInt;
  597.         Test      : Integer;
  598.         dt        : DateTime;
  599.  
  600.       BEGIN
  601.         rest:=TrimRest;
  602.         CASE TokenNr of
  603.            1 : FileFwdRec.FileName:=Rest;
  604.            2 : FileFwdRec.WhereToPut:=Rest;
  605.            3 : FileFwdRec.AddToFiles:=Rest='YES';
  606.            4 : Val(Rest,FileFwdRec.AddBeforeLine,Test);
  607.            5 : FileFwdRec.Description:=Rest;
  608.            6 : BEGIN
  609.                  rest:=Rest+' ';
  610.                  FileFwdRec.SendTo[1]:=copy(rest,1,Pos('@',rest)-1);
  611.                  FileFwdRec.SendTo[2]:=copy(rest,Pos('@',rest)+1,255);
  612.                END;
  613.            7 : FileFwdRec.BeforeCmd:=Rest;
  614.            8 : FileFwdRec.AfterCmd:=Rest;
  615.            9 : FileFwdRec.TouchFile:=Rest='YES';
  616.           10 : GetAdressFromStr(Rest,FileFwdRec.GetFrom);
  617.           11 : BEGIN
  618.                  VAL(COPY(rest,1,2),dt.Day,Test);
  619.                  VAL(COPY(rest,4,2),dt.Month,Test);
  620.                  VAL(COPY(rest,7,2),dt.Year,Test);
  621.                  VAL(COPY(rest,10,2),dt.Hour,Test);
  622.                  VAL(COPY(rest,13,2),dt.Min,Test);
  623.                  VAL(COPY(rest,16,2),dt.Sec,Test);
  624.                  PackTime(dt,w);
  625.                  FileFwdRec.LastForward:=w;
  626.                END;
  627.           12 : FileFwdRec.KillDupe:=Rest='YES';
  628.           13 : FileFwdRec.CheckDate:=Rest='YES';
  629.           14 : Val(Rest,FileFwdRec.Level,Test);
  630.           15 : Val(Rest,FileFwdRec.keys,Test);
  631.           16 : FileFwdRec.PortalFixName:=Rest;
  632.           17 : Val(Rest,FileFwdRec.KeepMax,Test);
  633.         END;
  634.       END;
  635.  
  636.       PROCEDURE ImportNlt;
  637.       BEGIN
  638.         rest:=TrimRest;
  639.         CASE TokenNr of
  640.            1 : NltRec.NumFrom:=Rest;
  641.            2 : NltRec.NumTo:=Rest;
  642.         END;
  643.       END;
  644.  
  645.       PROCEDURE ImportScd;
  646.       Var
  647.         Test      : Integer;
  648.  
  649.       BEGIN
  650.         rest:=TrimRest;
  651.         CASE TokenNr of
  652.            1 : Val(Rest,ScdRec.Number,Test);
  653.            2 : Val(Rest,ScdRec.Action,Test);
  654.            3 : BEGIN
  655.                  rest:=Rest+' ';
  656.                  ScdRec.Adr[1]:=copy(rest,1,Pos('@',rest)-1);
  657.                  ScdRec.Adr[2]:=copy(rest,Pos('@',rest)+1,255);
  658.                END;
  659.            4 : ScdRec.stat:=Rest[1];
  660.            5 : Val(Rest,ScdRec.Subline,Test);
  661.         END;
  662.       END;
  663.  
  664.       PROCEDURE Importokf;
  665.       Var
  666.         w         : Longint;
  667.         Test      : Integer;
  668.  
  669.       BEGIN
  670.         rest:=TrimRest;
  671.         CASE TokenNr of
  672.            1 : BEGIN
  673.                  mainstrdict^.member(rest,w);
  674.                  OkfRec.nodestat:=Tnodestat(w-570);
  675.                END;
  676.            2 : OkfRec.MagicName:=rest;
  677.            3 : Okfrec.FilePath:=rest;
  678.            4 : OkfRec.Password:=Rest;
  679.            5 : Val(Rest,okfRec.Level,Test);
  680.            6 : Val(Rest,okfRec.Keys,Test);
  681.            7 : BEGIN
  682.                  mainstrdict^.member(rest,w);
  683.                  OkfRec.FreeArea:=TFreeArea(w-550);
  684.                END;
  685.            8 : Val(Rest,okfRec.Tasknumber,Test);
  686.         END;
  687.       END;
  688.  
  689.       PROCEDURE ImportAreas;
  690.       Var
  691.         w         : Longint;
  692.         Test      : Integer;
  693.  
  694.       BEGIN
  695.         rest:=TrimRest;
  696.         CASE TokenNr of
  697.            1 : AreaRec.Directory:=rest;
  698.            2 : BEGIN
  699.                  AreaRec.EchoNames[1]:=NextWord('@',rest);
  700.                  AreaRec.EchoNames[2]:=NextWord('@',rest);
  701.                  AreaRec.Echonames[3]:=rest;
  702.                END;
  703.            3 : AreaRec.Origin:=rest;
  704.            4 : BEGIN
  705.                  AreaRec.SendTo[1]:=NextWord('@',rest);
  706.                  AreaRec.SendTo[2]:=rest;
  707.                END;
  708.            5 : BEGIN
  709.                  AreaRec.Sendonly[1]:=NextWord('@',rest);
  710.                  AreaRec.Sendonly[2]:=rest;
  711.                END;
  712.            6 : AreaRec.ScramblePwd:=rest;
  713.            7 : AreaRec.StripSeenBy:=rest='YES';
  714.            8 : AreaRec.Pvt2Email:=Rest='YES';
  715.            9 : Val(Rest,AreaRec.Level,Test);
  716.           10 : Val(Rest,AreaRec.Keys,Test);
  717.           11 : Val(Rest,AreaRec.MaxScan,Test);
  718.           12 : AreaRec.ScanDate:=DateStringToDate('dd.mm.yy',rest);
  719.           13 : Val(Rest,AreaRec.Scanned,Test);
  720.           14 : AreaRec.Description:=rest;
  721.           15 : Val(Rest,AreaRec.AreaType,Test);
  722.           16 : AreaRec.ImportSB:=Rest='YES';
  723.           17 : Val(Rest,AreaRec.UsedAka,Test);
  724.           18 : Val(Rest,AreaRec.MsgCount,Test);
  725.           19 : Val(Rest,AreaRec.DateCount,Test);
  726.           20 : Val(Rest,AreaRec.MsgKeep,Test);
  727.         END;
  728.       END;
  729.  
  730.       PROCEDURE ImportNls;
  731.       Var
  732.         w         : Longint;
  733.         Test      : Integer;
  734.       BEGIN
  735.         rest:=TrimRest;
  736.         CASE TokenNr of
  737.            1 : NlsRec.NodeListName:=rest;
  738.            2 : NlsRec.DiffFileName:=rest;
  739.            3 : Nlsrec.CheckCRC:=rest='YES';
  740.            4 : NlsRec.NewNlPath:=Rest;
  741.            5 : BEGIN
  742.                  NlsRec.Include[1]:=NextWord('@',rest);
  743.                  NlsRec.Include[2]:=rest;
  744.                END;
  745.            6 : BEGIN
  746.                  NlsRec.Exclude[1]:=NextWord('@',rest);
  747.                  NlsRec.Exclude[2]:=rest;
  748.                END;
  749.            7 : NlsRec.NewNlDesc:=Rest;
  750.         END;
  751.       END;
  752.  
  753.       PROCEDURE ImportMFS;
  754.       Var
  755.         w         : Longint;
  756.         Test      : Integer;
  757.       BEGIN
  758.         rest:=TrimRest;
  759.         CASE TokenNr of
  760.            1 : MFSRec.Name:=rest;
  761.            2 : MFSRec.FileName:=rest;
  762.            3 : MFSrec.HeaderFile:=rest;
  763.            4 : BEGIN
  764.                  MFSRec.IncludeAreas[1]:=NextWord('@',rest);
  765.                  MFSRec.IncludeAreas[2]:=NextWord('@',rest);
  766.                  MFSRec.IncludeAreas[3]:=NextWord('@',rest);
  767.                  MFSRec.IncludeAreas[4]:=rest;
  768.                END;
  769.            6 : MFSRec.Doafter:=rest;
  770.         END;
  771.       END;
  772.  
  773.       PROCEDURE SkrivAst;
  774.       Var
  775.         Ch : Char;
  776.       BEGIN
  777.         inc(AstCount);
  778.         if Astcount>4 then astcount:=1;
  779.         CASE AstCount of
  780.           1 : ch:='-';
  781.           2 : ch:='\';
  782.           3 : ch:='|';
  783.           4 : ch:='/';
  784.         END;
  785.         win^.WFasttext(ch,2,12);
  786.       END;
  787.  
  788.     BEGIN
  789.       Assign(f, FName); Reset(f);
  790.       IF IOResult=0 THEN
  791.       BEGIN
  792.         New(LocalStrDict,init);
  793.         Section:=0; OldSection:=-1;
  794.         WHILE NOT EoF(f) DO
  795.         BEGIN
  796.           ReadLn(f, s);
  797.           IF (Length(s)>0) AND (Copy(s, 1, 1)<>';') THEN
  798.           BEGIN
  799.             Split(s, Token, Rest);
  800.             IF Section<>0 THEN
  801.             BEGIN
  802.               IF NOT LocalStrDict^.Member(Token, TokenNr) THEN
  803.                 IF (MainStrDict^.Member(Token, TokenNr)) AND (TokenNr=3) THEN
  804.                   Section:=0
  805.                 ELSE
  806.                   TokenNr:=0;
  807.             END;
  808.             CASE Section OF
  809.                0: BEGIN
  810.                     IF NOT MainStrDict^.Member(Token, TokenNr) THEN TokenNr:=0;
  811.                     CASE TokenNr OF
  812.                        1 : ImportFile(Rest);   { Include }
  813.                        3 : BEGIN               { End }
  814.                              SkrivAst;
  815. {                            if Filerec(tmpfile).mode<>FmClosed then Seek(TmpFile,FileSize(TmpFile));}
  816.                              TmpFile.Seek(TmpFile.FileSize);
  817.                              CASE OldSection OF
  818.                                50 : BEGIN
  819.                                       TmpFile.Write(CurrentEvent);
  820.                                       FillChar(CurrentEvent,Sizeof(TEvent),#0);
  821.                                     END;
  822.                                51 : BEGIN
  823.                                       TmpFile.Write(NodesRec);
  824.                                       FillChar(NodesRec,Sizeof(TNodeInfo),#0);
  825.                                     END;
  826.                                52 : BEGIN
  827.                                       TmpFile.Write(TickRec);
  828.                                       FillChar(TickRec,Sizeof(TTickArea),#0);
  829.                                     END;
  830.                                53 : BEGIN
  831.                                       TmpFile.Write(FileFwdRec);
  832.                                       FillChar(FileFwdRec,SizeOf(TFileFwd),#0);
  833.                                     END;
  834.                                54 : BEGIN
  835.                                       TmpFile.Write(NltRec);
  836.                                       FillChar(NltRec,SizeOf(TNLTranslat),#0);
  837.                                     END;
  838.                                55 : BEGIN
  839.                                       TmpFile.Write(ScdRec);
  840.                                       FillChar(ScdRec,SizeOf(TSchedule),#0);
  841.                                     END;
  842.                                56 : BEGIN
  843.                                       TmpFile.Write(OkfRec);
  844.                                       FillChar(OkfRec,SizeOf(TOkfile),#0);
  845.                                     END;
  846.                                57 : BEGIN
  847.                                       TmpFile.Write(AreaRec);
  848.                                       FillChar(AreaRec,SizeOf(TMsgArea),#0);
  849.                                     END;
  850.                                58 : BEGIN
  851.                                       TmpFile.Write(NlsRec);
  852.                                       FillChar(NlsRec,SizeOf(TNodelistSeg),#0);
  853.                                     END;
  854.                              END;
  855.                            END;
  856.                   10..24 : IF MainStrDict^.Member(Token, TokenNr) {AND (TokenNr=2)} THEN
  857.                            BEGIN
  858.                              Section:=TokenNr;
  859.                              ResLib.GetEntry('TOK'+To3(Section), LocalStrDict^);
  860.                            END;
  861.                   50..59 : BEGIN
  862.                              Section:=TokenNr;
  863.                              IF (Section<>OldSection) THEN
  864.                              BEGIN
  865. {                              IF (FileRec(TmpFile).Mode<>fmClosed) THEN NetCloseFile(TmpFile);}
  866.                                TmpFile.Close;
  867.                                LocalStrDict^.Done;
  868.                                LocalStrDict^.Init;
  869.                                ResLib.GetEntry('TOK'+To3(Section), LocalStrDict^);
  870.                                CASE Section OF
  871.                                  50 : BEGIN
  872.                                         TmpFile.Open(PoPEventFileName,SizeOf(TEvent),TRUE);
  873.                                         IF Overwrite THEN TmpFile.Truncate;
  874.                                         FillChar(CurrentEvent,Sizeof(TEvent),#0);
  875.                                       END;
  876.                                  51 : BEGIN
  877.                                         TmpFile.Open(PoPNodesFileName,SizeOf(TNodeInfo),TRUE);
  878.                                         IF Overwrite THEN TmpFile.Truncate;
  879.                                         FillChar(NodesRec,Sizeof(TNodeInfo),#0);
  880.                                       END;
  881.                                  52 : BEGIN
  882.                                         TmpFile.Open(PopTickFileName,SizeOf(TTickArea),TRUE);
  883.                                         IF Overwrite THEN TmpFile.Truncate;
  884.                                         FillChar(TickRec,Sizeof(TTickArea),#0);
  885.                                       END;
  886.                                  53 : BEGIN
  887.                                         TmpFile.Open(PoPFileFwdFileName,SizeOf(TFileFwd),TRUE);
  888.                                         IF Overwrite THEN TmpFile.Truncate;
  889.                                         FillChar(FileFwdRec,SizeOf(TFileFwd),#0);
  890.                                       END;
  891.                                  54 : BEGIN
  892.                                         TmpFile.Open(PoPNLTranslateFileName,SizeOf(TNLTranslat),TRUE);
  893.                                         IF Overwrite THEN TmpFile.Truncate;
  894.                                         FillChar(NltRec,SizeOf(TNlTranslat),#0);
  895.                                       END;
  896.                                  55 : BEGIN
  897.                                         TmpFile.Open(PoPScheduleFileName,SizeOf(TSchedule),TRUE);
  898.                                         IF Overwrite THEN TmpFile.Truncate;
  899.                                         FillChar(ScdRec,SizeOf(TSchedule),#0);
  900.                                       END;
  901.                                  56 : BEGIN
  902.                                         TmpFile.Open(PoPOkFileName,SizeOf(TOkfile),TRUE);
  903.                                         IF Overwrite THEN TmpFile.Truncate;
  904.                                         FillChar(OkfRec,SizeOf(TOkfile),#0);
  905.                                       END;
  906.                                  57 : BEGIN
  907.                                         TmpFile.Open(PoPMsgAreaFileName,SizeOf(TMsgArea),TRUE);
  908.                                         IF Overwrite THEN TmpFile.Truncate;
  909.                                         FillChar(areaRec,SizeOf(TmsgArea),#0);
  910.                                       END;
  911.                                  58 : BEGIN
  912.                                         TmpFile.Open(PoPNLSegmentFileName,SizeOf(TNodelistseg),TRUE);
  913.                                         IF Overwrite THEN TmpFile.Truncate;
  914.                                         FillChar(NlsRec,SizeOf(TnodelistSeg),#0);
  915.                                       END;
  916.                                  59 : BEGIN
  917.                                         TmpFile.Open(PoPListSegmentsName,SizeOf(TFilelistsegment),TRUE);
  918.                                         IF Overwrite THEN TmpFile.Truncate;
  919.                                         FillChar(MFSRec,SizeOf(TFileListSegment),#0);
  920.                                       END;
  921.                                END;
  922.                                OldSection:=Section;
  923.                              END;
  924.                            END;
  925.                     END;
  926.                   END;
  927.               10: ImportSystem;
  928.               11: ImportBBs;
  929.               12: ImportModem;
  930.               13: ImportScreen;
  931.               14: ImportListFile;
  932.               15: ImportRequest;
  933.               16: ImportMailScanner;
  934.               17: ImportFileFwd;
  935.               18: ImportTick;
  936.               19: ImportBiMail;
  937.               20: ImportNodeListComp;
  938.               21: ImportDumbTerm;
  939.               22: ImportExtProt;
  940.               23: ImportAreaMan;
  941.               24: ImportPackers;
  942.               50: ImportEventfile;
  943.               51: ImportNodesFile;
  944.               52: ImportTickFile;
  945.               53: ImportFileForward;
  946.               54: ImportNLT;
  947.               55: ImportScd;
  948.               56: ImportOkf;
  949.               57: ImportAreas;
  950.               58: ImportNls;
  951.               59: ImportMFS;
  952.             END;
  953.           END;
  954.         END;
  955.         Dispose(LocalStrDict, Done);
  956.         Close(f);
  957.       END;
  958.     END;
  959.  
  960.   BEGIN
  961.     AdrNum:=0;
  962.     FName:=StartPath+PoPCfgExportFileName;
  963.     IF SelectFile(Fname) THEN
  964.     BEGIN
  965.       Overwrite:=Confirm('Overwrite existing datafiles', 'N', 14);
  966. {     FileRec(TmpFile).Mode:=fmClosed;}
  967.       New(MainStrDict,init);
  968.       ResLib.GetEntry('TOK000', MainStrDict^);
  969.       Astcount:=0;
  970.       MyWin(win,10,10,24,13,2,'Importing',true);
  971.       Win^.Wfasttext('Reading.',2,2);
  972.       ImportFile(FName);
  973.       Dispose(MainStrDict, Done);
  974. {      IF FileRec(TmpFile).Mode<>fmClosed THEN NetCloseFile(TmpFile);}
  975.       TmpFile.Close;
  976.       Addlog('+','Configuration imported');
  977.       KillWindow(win);
  978.     END;
  979.   END;
  980.  
  981. END.
  982.